'use strict';

const db = uniCloud.database();
const _ = db.command;

/**
 * 更新订单状态
 * 0=待处理、1=已接单、2=制作中、3=已完成
 * 
 * 状态流转规则：
 * - 用户可取消待处理(0)的订单（改为-1取消状态）
 * - 厨师只能按顺序更新：0->1->2->3
 * - 订单一旦被接单(1)后，用户不能再取消
 * 
 * @param {string} orderId - 订单 ID
 * @param {number} status - 新状态 (-1=取消, 0-3=正常流转)
 * @param {string} reason - 取消原因（可选）
 * @returns {object} 更新结果
 */
exports.main = async (event, context) => {
  const { orderId, status, reason } = event.data || {};
  
  console.log('update-order-status 收到请求:', { orderId, status, reason });
  console.log('context.auth:', context.auth);
  
  // 获取用户信息
  let uid = context.auth?.uid;
  let userRole = context.auth?.role || [];
  
  // 如果 context.auth 为空，尝试从 event 中获取 token 并手动验证
  if (!uid && event.uniIdToken) {
    try {
      const jwtToken = require('jsonwebtoken');
      const decoded = jwtToken.decode(event.uniIdToken);
      console.log('解析的 token 内容:', decoded);
      if (decoded && decoded.uid) {
        uid = decoded.uid;
        userRole = decoded.role || [];
      }
    } catch (err) {
      console.error('Token 解析失败:', err);
    }
  }
  
  console.log('获取到的用户信息:', { uid, userRole });
  
  if (!uid) {
    return {
      code: 401,
      message: '未授权，请先登录',
      data: null
    };
  }

  // 验证参数
  if (!orderId || status === undefined) {
    return {
      code: 400,
      message: '缺少必要参数：orderId、status',
      data: null
    };
  }

  // 允许的状态：-1(取消)、0-3(正常流转)
  if (![-1, 0, 1, 2, 3].includes(status)) {
    return {
      code: 400,
      message: '无效的订单状态',
      data: null
    };
  }

  try {
    // 查询订单
    const orderRes = await db.collection('food-order').doc(orderId).get();
    
    if (!orderRes.data || orderRes.data.length === 0) {
      return {
        code: 404,
        message: '订单不存在',
        data: null
      };
    }

    const order = orderRes.data[0];
    const oldStatus = order.status;
    const isChef = userRole.includes('chef');
    const isOwner = uid === order.user_id;

    // ============ 权限检查 ============
    
    // 取消订单（status = -1）
    if (status === -1) {
      // 只有订单所有者可以取消
      if (!isOwner) {
        return {
          code: 403,
          message: '只有订单所有者可以取消订单',
          data: null
        };
      }
      
      // 只有待处理的订单才能取消
      if (oldStatus !== 0) {
        return {
          code: 400,
          message: '只有待处理的订单才能取消',
          data: null
        };
      }
    } else {
      // 正常状态流转：只有厨师才能更新
      if (!isChef) {
        return {
          code: 403,
          message: '只有厨师可以更新订单状态',
          data: null
        };
      }

      // ============ 状态流转验证 ============
      const allowedTransitions = {
        0: [1],        // 待处理 -> 已接单
        1: [2],        // 已接单 -> 制作中
        2: [3],        // 制作中 -> 已完成
        3: [],         // 已完成 (终态，不能转移)
        '-1': []       // 已取消 (终态，不能转移)
      };

      if (!allowedTransitions[oldStatus]?.includes(status)) {
        return {
          code: 400,
          message: `无法从状态 ${oldStatus} 转移到状态 ${status}`,
          data: null
        };
      }
    }

    // ============ 构建更新数据 ============
    
    const now = new Date();
    
    // 初始化 status_time 如果不存在
    let statusTime = order.status_time || {
      created: order.create_date || now
    };

    // 根据新状态更新对应的时间戳
    switch (status) {
      case 1: // 已接单
        statusTime.accepted = now;
        break;
      case 2: // 制作中
        statusTime.started = now;
        break;
      case 3: // 已完成
        statusTime.completed = now;
        break;
      case -1: // 取消
        statusTime.cancelled = now;
        statusTime.cancelReason = reason || '用户取消';
        break;
    }

    // 更新订单
    const updateData = {
      status,
      status_time: statusTime,
      update_date: new Date()
    };

    const updateRes = await db
      .collection('food-order')
      .doc(orderId)
      .update(updateData);

    // 新 API：使用 updated 代替 affectedDocs
    const updated = updateRes.updated || 0;
    
    if (updated === 0) {
      console.warn('未更新任何文档');
    }

    const action = status === -1 ? '已取消' : `更新为状态 ${status}`;

    return {
      code: 200,
      message: `订单${action}成功`,
      data: {
        orderId,
        oldStatus,
        newStatus: status,
        statusTime,
        message: status === -1 ? `订单已取消${reason ? `，原因：${reason}` : ''}` : '订单状态已更新'
      }
    };
  } catch (error) {
    console.error('更新订单状态出错:', error);
    return {
      code: 500,
      message: error.message || '更新订单状态失败',
      data: null
    };
  }
};
